/**
 * 权限保护组件 - 统一的权限控制
 */

import React from 'react';
import { Result, Button } from 'antd';
import { useNavigate } from 'react-router-dom';
import { usePermission } from '../hooks/usePermission';

interface PermissionGuardProps {
  /** 所需权限（单个权限或权限数组） */
  permission?: string | string[];
  /** 资源名称（配合action使用） */
  resource?: string;
  /** 操作名称（配合resource使用） */
  action?: string;
  /** 需要所有权限（默认false，即任一权限即可） */
  requireAll?: boolean;
  /** 无权限时显示的内容 */
  fallback?: React.ReactNode;
  /** 子组件 */
  children: React.ReactNode;
}

/**
 * 权限保护组件
 */
export const PermissionGuard: React.FC<PermissionGuardProps> = ({
  permission,
  resource,
  action,
  requireAll = false,
  fallback,
  children
}) => {
  const { 
    hasPermission, 
    hasAnyPermission, 
    hasAllPermissions, 
    canPerformAction,
    isSuperUser 
  } = usePermission();
  
  const navigate = useNavigate();

  // 超级用户拥有所有权限
  if (isSuperUser) {
    return <>{children}</>;
  }

  let hasAccess = false;

  // 基于资源-操作的权限检查
  if (resource && action) {
    hasAccess = canPerformAction(resource, action);
  }
  // 基于权限名称的检查
  else if (permission) {
    if (Array.isArray(permission)) {
      hasAccess = requireAll 
        ? hasAllPermissions(permission)
        : hasAnyPermission(permission);
    } else {
      hasAccess = hasPermission(permission);
    }
  }
  // 如果没有指定权限要求，默认允许访问
  else {
    hasAccess = true;
  }

  // 有权限时显示子组件
  if (hasAccess) {
    return <>{children}</>;
  }

  // 无权限时显示fallback或默认的无权限提示
  if (fallback) {
    return <>{fallback}</>;
  }

  return (
    <Result
      status="403"
      title="403"
      subTitle="抱歉，您没有权限访问此内容"
      extra={
        <Button type="primary" onClick={() => navigate(-1)}>
          返回上一页
        </Button>
      }
    />
  );
};

/**
 * 页面级权限保护组件
 */
interface PageGuardProps {
  /** 所需权限 */
  permission: string;
  /** 子组件 */
  children: React.ReactNode;
}

export const PageGuard: React.FC<PageGuardProps> = ({ permission, children }) => {
  return (
    <PermissionGuard permission={permission}>
      {children}
    </PermissionGuard>
  );
};

/**
 * 操作按钮权限保护组件
 */
interface ActionGuardProps {
  /** 资源名称 */
  resource: string;
  /** 操作名称 */
  action: string;
  /** 无权限时是否隐藏（默认true） */
  hideWhenNoPermission?: boolean;
  /** 无权限时的替代内容 */
  fallback?: React.ReactNode;
  /** 子组件 */
  children: React.ReactNode;
}

export const ActionGuard: React.FC<ActionGuardProps> = ({
  resource,
  action,
  hideWhenNoPermission = true,
  fallback,
  children
}) => {
  const { canPerformAction, isSuperUser } = usePermission();

  // 超级用户拥有所有权限
  if (isSuperUser) {
    return <>{children}</>;
  }

  const hasAccess = canPerformAction(resource, action);

  if (hasAccess) {
    return <>{children}</>;
  }

  // 无权限时的处理
  if (hideWhenNoPermission) {
    return null; // 隐藏组件
  }

  return <>{fallback}</>;
};

/**
 * 权限检查高阶组件
 */
export const withPermission = (
  permission: string | string[],
  options?: {
    requireAll?: boolean;
    fallback?: React.ReactNode;
  }
) => {
  return function<P extends object>(Component: React.ComponentType<P>) {
    return function PermissionWrapper(props: P) {
      return (
        <PermissionGuard 
          permission={permission} 
          requireAll={options?.requireAll}
          fallback={options?.fallback}
        >
          <Component {...props} />
        </PermissionGuard>
      );
    };
  };
};

/**
 * 资源操作权限检查高阶组件
 */
export const withResourceAction = (
  resource: string,
  action: string,
  options?: {
    fallback?: React.ReactNode;
  }
) => {
  return function<P extends object>(Component: React.ComponentType<P>) {
    return function ResourceActionWrapper(props: P) {
      return (
        <PermissionGuard 
          resource={resource}
          action={action}
          fallback={options?.fallback}
        >
          <Component {...props} />
        </PermissionGuard>
      );
    };
  };
};

export default PermissionGuard;
